// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// go:build js&&wasm 

package runtime

import (
	"unsafe"
)

func exit(code int32)

func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
	if fd > 2 {
		throw("runtime.write to fd > 2 is unsupported")
	}
	wasmWrite(fd, p, n)
	return n
}

// 存根，以便测试可以正确链接。这些永远不应该被称为。
func open(name *byte, mode, perm int32) int32        { panic("not implemented") }
func closefd(fd int32) int32                         { panic("not implemented") }
func read(fd int32, p unsafe.Pointer, n int32) int32 { panic("not implemented") }

// go:noescape 
func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)

func usleep(usec uint32)

// go:nosplit 
func usleep_no_g(usec uint32) {
	usleep(usec)
}

func exitThread(wait *uint32)

type mOS struct{}

func osyield()

// go:nosplit 
func osyield_no_g() {
	osyield()
}

const _SIGSEGV = 0xb

func sigpanic() {
	g := getg()
	if !canpanic(g) {
		throw("unexpected signal during runtime execution")
	}

	// js仅对内存故障调用异常处理程序。
	g.sig = _SIGSEGV
	panicmem()
}

type sigset struct{}

// 调用以初始化新的m（包括引导程序m）。
// 在父线程（引导时为主线程）上调用，可以分配内存。
func mpreinit(mp *m) {
	mp.gsignal = malg(32 * 1024)
	mp.gsignal.m = mp
}

// go:nosplit 
func sigsave(p *sigset) {
}

// go:nosplit 
func msigrestore(sigmask sigset) {
}

// go:nosplit 
// go:NOWRITEBRIERREC 
func clearSignalHandlers() {
}

// go nosplit 
func sigblock(exiting bool) {
}

// 调用以初始化新m（包括引导程序m）。
// 在新线程上调用，无法分配内存。
func minit() {
}

// 从dropm调用以撤消minit的效果。
func unminit() {
}

// 从exitm调用，但不是从drop调用，以撤销线程拥有的
// minit、semacreate或其他资源的效果。打完电话后不要带锁。
func mdestroy(mp *m) {
}

func osinit() {
	ncpu = 1
	getg().m.procid = 2
	physPageSize = 64 * 1024
}

// wasm没有信号
const _NSIG = 0

func signame(sig uint32) string {
	return ""
}

func crash() {
	*(*int32)(nil) = 0
}

func getRandomData(r []byte)

func goenvs() {
	goenvs_unix()
}

func initsig(preinit bool) {
}

// 可能在m.p==nil的情况下运行，因此不允许使用写屏障。
// go:nowritebarrier 
func newosproc(mp *m) {
	panic("newosproc: not implemented")
}

func setProcessCPUProfiler(hz int32) {}
func setThreadCPUProfiler(hz int32)  {}
func sigdisable(uint32)              {}
func sigenable(uint32)               {}
func sigignore(uint32)               {}

// go:linkname os_sigpipe os。sigpipe 
func os_sigpipe() {
	throw("too many writes on closed pipe")
}

// go:nosplit 
func cputicks() int64 {
	// 目前cputicks（）用于blocking profiler和种子运行时·fastrand（）。
	// runtime·nanotime（）是一个很差的CPU周期近似值，对于探查器来说已经足够了。
	return nanotime()
}

// go:linkname syscall\u now syscall。现在
func syscall_now() (sec int64, nsec int32) {
	sec, nsec, _ = time_now()
	return
}

// gsignalStack在js上未使用。
type gsignalStack struct{}

const preemptMSupported = false

func preemptM(mp *m) {
	// 没有线程，因此无需执行任何操作。
}
